package com.lyc.service.impl;

import com.lyc.mapper.CommentLikesMapper;
import com.lyc.mapper.CommentMapper;
import com.lyc.pojo.Comment;
import com.lyc.pojo.CommentLikes;
import com.lyc.service.CommentService;
import com.lyc.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class CommentServiceImpl implements CommentService {
    
    @Autowired
    private CommentMapper commentMapper;
    
    @Autowired
    private CommentLikesMapper commentLikesMapper;

    // 获取
    @Override
    public List<Comment> getCommentsByPostId(Integer postId) {
        return commentMapper.findByPostId(postId);
    }
    
    // 获取分层评论
    @Override
    public List<Comment> getHierarchicalCommentsByPostId(Integer postId) {
        // 获取所有评论
        List<Comment> allComments = commentMapper.findByPostId(postId);
        
        // 分离顶级评论和子评论
        List<Comment> topLevelComments = allComments.stream()
                .filter(comment -> comment.getParentId() == null || comment.getParentId() == 0)
                .collect(Collectors.toList());
        
        // 为每个顶级评论添加子评论
        for (Comment topLevelComment : topLevelComments) {
            topLevelComment.setReplies(getReplies(topLevelComment.getId(), allComments));
        }
        
        return topLevelComments;
    }
    
    /**
     * 获取指定评论的所有直接回复
     * @param parentId 父评论ID
     * @param allComments 所有评论列表
     * @return 直接回复列表
     */
    private List<Comment> getReplies(Integer parentId, List<Comment> allComments) {
        return allComments.stream()
                .filter(comment -> comment.getParentId() != null && comment.getParentId().equals(parentId))
                .collect(Collectors.toList());
    }

    // 添加
    @Override
    public boolean addComment(Comment comment) {
        // 检查postId是否为空
        if (comment.getPostId() == null) {
            throw new IllegalArgumentException("帖子ID不能为空");
        }
        
        // 设置评论创建时间和更新时间
        comment.setCreatedAt(LocalDateTime.now());
        comment.setUpdatedAt(LocalDateTime.now());
        
        // 如果没有设置用户ID，则从ThreadLocal中获取当前登录用户ID
        if (comment.getUserId() == null) {
            Map<String, Object> map = ThreadLocalUtil.get();
            Integer userId = (Integer) map.get("id");
            comment.setUserId(userId);
        }
        
        // 设置默认状态为正常
        if (comment.getStatus() == null || comment.getStatus().isEmpty()) {
            comment.setStatus("normal");
        }
        
        // 设置默认父评论ID为0（顶级评论）
        if (comment.getParentId() == null) {
            comment.setParentId(0);
        }
        
        return commentMapper.insert(comment) > 0;
    }

    // 删除
    @Override
    public boolean deleteComment(Integer commentId, Integer userId) {
        // 验证评论是否存在
        Comment comment = commentMapper.findById(commentId);
        if (comment == null) {
            return false;
        }
        
        // 验证是否有权限删除（评论创建者或管理员）
        if (!comment.getUserId().equals(userId)) {
            return false;
        }
        
        // 删除该评论下的所有子评论
        commentMapper.deleteByParentId(commentId);
        
        // 删除评论
        return commentMapper.deleteById(commentId) > 0;
    }

    // 点赞
    @Override
    public boolean likeComment(Integer commentId, Integer userId) {
        // 验证评论是否存在
        Comment comment = commentMapper.findById(commentId);
        if (comment == null) {
            return false;
        }
        
        // 检查用户是否已经点赞
        CommentLikes existingLike = commentLikesMapper.findByCommentIdAndUserId(commentId, userId);
        
        if (existingLike != null) {
            // 如果已经点赞，则取消点赞
            commentLikesMapper.deleteByCommentIdAndUserId(commentId, userId);
            
            // 减少评论点赞数
            commentMapper.decrementLikeCount(commentId);
        } else {
            // 如果未点赞，则添加点赞记录
            CommentLikes commentLikes = new CommentLikes();
            commentLikes.setCommentId(commentId);
            commentLikes.setUserId(userId);
            commentLikes.setCreatedAt(LocalDateTime.now());
            commentLikesMapper.insert(commentLikes);
            
            // 增加评论点赞数
            commentMapper.incrementLikeCount(commentId);
        }
        
        return true;
    }
    
    // 检查评论点赞状态
    @Override
    public Set<Integer> checkCommentsLikeStatus(List<Integer> commentIds, Integer userId) {
        if (commentIds == null || commentIds.isEmpty()) {
            return new HashSet<>();
        }
        
        return commentLikesMapper.findUserLikedComments(commentIds, userId);
    }
    
    // 获取所有评论（供管理端使用）
    @Override
    public List<Comment> getAllComments() {
        return commentMapper.findAll();
    }
    
    // 管理端删除评论
    @Override
    public boolean deleteCommentByAdmin(Integer commentId) {
        // 验证评论是否存在
        Comment comment = commentMapper.findById(commentId);
        if (comment == null) {
            return false;
        }
        
        // 删除该评论下的所有子评论
        commentMapper.deleteByParentId(commentId);
        
        // 删除评论
        return commentMapper.deleteById(commentId) > 0;
    }
    
    // 管理端批量删除评论
    @Override
    public boolean batchDeleteCommentsByAdmin(List<Integer> commentIds) {
        if (commentIds == null || commentIds.isEmpty()) {
            return false;
        }
        
        // 对于每个评论，先删除其子评论
        for (Integer commentId : commentIds) {
            commentMapper.deleteByParentId(commentId);
        }
        
        // 批量删除评论
        return commentMapper.batchDeleteByIds(commentIds) > 0;
    }
}